/**
 * 项目进度计算工具函数
 * 与后端 calculate_project_progress 函数逻辑保持一致
 */

export interface ProjectProgressParams {
  requirement_count?: number
  requirement_completed_count?: number
  task_count?: number
  completed_task_count?: number
  defect_count?: number
  resolved_defect_count?: number
  test_case_count?: number
  passed_test_case_count?: number
  project_status?: string
  start_date?: string | Date
  end_date?: string | Date
  progress?: number | null
}

/**
 * 计算项目进度（多维度加权平均）
 * 
 * 计算方案：
 * 1. 需求完成率（权重：40%）
 * 2. 任务完成率（权重：35%）
 * 3. 缺陷解决率（权重：15%）
 * 4. 测试用例通过率（权重：10%）
 * 
 * 如果项目状态是已完成/已归档，直接返回100%
 * 如果项目状态是已取消，返回0%
 * 如果没有任何数据，根据项目状态返回默认进度
 */
export function calculateProjectProgress(params: ProjectProgressParams): number {
  // 如果后端已经返回了进度，直接使用
  if (params.progress !== undefined && params.progress !== null) {
    return params.progress
  }

  const {
    requirement_count = 0,
    requirement_completed_count = 0,
    task_count = 0,
    completed_task_count = 0,
    defect_count = 0,
    resolved_defect_count = 0,
    test_case_count = 0,
    passed_test_case_count = 0,
    project_status,
    start_date,
    end_date
  } = params

  // 如果项目状态是已完成/已归档，直接返回100%
  if (project_status) {
    const statusLower = project_status.toLowerCase()
    if (['done', 'completed', 'finished', '已完', '归档'].some(keyword => statusLower.includes(keyword))) {
      return 100
    }
    // 如果项目状态是已取消，返回0%
    if (['cancelled', 'cancel', '已取消', '取消'].some(keyword => statusLower.includes(keyword))) {
      return 0
    }
  }

  // 计算各项完成率
  let requirementProgress = 0
  if (requirement_count > 0) {
    requirementProgress = (requirement_completed_count / requirement_count) * 100
  } else if (requirement_count === 0 && task_count === 0 && defect_count === 0 && test_case_count === 0) {
    // 如果没有任何数据，根据项目状态返回默认进度
    if (project_status) {
      const statusLower = project_status.toLowerCase()
      if (['planning', '规划', '草稿', 'draft'].some(keyword => statusLower.includes(keyword))) {
        return 5
      } else if (['in_progress', '进行', '开发', '开发中'].some(keyword => statusLower.includes(keyword))) {
        return 30
      } else if (['testing', '测试', '测试中'].some(keyword => statusLower.includes(keyword))) {
        return 70
      } else if (['review', '评审', '预发布'].some(keyword => statusLower.includes(keyword))) {
        return 90
      }
    }
    return 0
  }

  let taskProgress = 0
  if (task_count > 0) {
    taskProgress = (completed_task_count / task_count) * 100
  }

  let defectProgress = 0
  if (defect_count > 0) {
    defectProgress = (resolved_defect_count / defect_count) * 100
  } else if (defect_count === 0) {
    // 如果没有缺陷，缺陷进度按100%计算（不影响整体进度）
    defectProgress = 100
  }

  let testCaseProgress = 0
  if (test_case_count > 0) {
    testCaseProgress = (passed_test_case_count / test_case_count) * 100
  } else if (test_case_count === 0) {
    // 如果没有测试用例，测试用例进度按100%计算（不影响整体进度）
    testCaseProgress = 100
  }

  // 计算加权平均
  let totalWeight = 0
  let weightedSum = 0

  // 需求权重：40%
  if (requirement_count > 0) {
    weightedSum += requirementProgress * 0.4
    totalWeight += 0.4
  }

  // 任务权重：35%
  if (task_count > 0) {
    weightedSum += taskProgress * 0.35
    totalWeight += 0.35
  }

  // 缺陷权重：15%（如果有缺陷数据）
  if (defect_count > 0) {
    weightedSum += defectProgress * 0.15
    totalWeight += 0.15
  }

  // 测试用例权重：10%（如果有测试用例数据）
  if (test_case_count > 0) {
    weightedSum += testCaseProgress * 0.1
    totalWeight += 0.1
  }

  // 如果没有任何有效数据，返回0
  if (totalWeight === 0) {
    return 0
  }

  // 计算加权平均进度
  let progress = weightedSum / totalWeight

  // 考虑时间进度作为上限参考（可选）
  if (start_date && end_date) {
    try {
      const start = typeof start_date === 'string' ? new Date(start_date) : start_date
      const end = typeof end_date === 'string' ? new Date(end_date) : end_date
      const now = new Date()

      if (now >= start && end > start) {
        const totalDuration = end.getTime() - start.getTime()
        const elapsedDuration = now.getTime() - start.getTime()
        if (totalDuration > 0) {
          const timeProgress = (elapsedDuration / totalDuration) * 100
          // 如果时间进度已经超过100%，且实际进度也接近完成，返回100%
          if (timeProgress >= 100 && progress >= 90) {
            return 100
          }
          // 如果实际进度远超时间进度（超过20%），适当调整
          // 但不超过时间进度+20%
          if (progress > timeProgress + 20) {
            progress = Math.min(progress, timeProgress + 20)
          }
        }
      }
    } catch (error) {
      // 如果日期计算出错，忽略时间因素
      console.warn('计算时间进度失败:', error)
    }
  }

  // 确保进度在0-100之间
  return Math.max(0, Math.min(100, Math.round(progress * 100) / 100))
}

